/**
 * 分支选择器组件
 * 用于展示和选择项目分支
 */

// 使用统一配置入口导入所需模块
const { branchService } = require('../../config/services_config');

Component({
  /**
   * 组件的属性列表
   */
  properties: {
    // 项目ID
    projectId: {
      type: String,
      value: '',
      observer: 'onProjectIdChanged'
    },
    // 当前选中的分支ID
    value: {
      type: String,
      value: ''
    },
    // 是否禁用
    disabled: {
      type: Boolean,
      value: false
    },
    // 显示模式：dropdown-下拉选择，tabs-标签式，simple-简单文本
    mode: {
      type: String,
      value: 'dropdown'
    },
    // 是否显示创建分支按钮
    showCreate: {
      type: Boolean,
      value: true
    }
  },

  /**
   * 组件的初始数据
   */
  data: {
    branches: [], // 分支列表
    loading: false, // 加载状态
    currentBranch: null, // 当前选中的分支
    selectedIndex: 0, // 当前选中的分支索引
    showCreateDialog: false, // 是否显示创建分支对话框
    newBranchData: { // 新分支数据
      name: '',
      description: '',
      type: 'feature'
    },
    newBranchTypeIndex: 0, // 新分支类型索引
    branchTypes: [
      { value: 'feature', label: '功能分支' },
      { value: 'bugfix', label: '修复分支' },
      { value: 'release', label: '发布分支' }
    ],
    error: '' // 错误信息
  },

  /**
   * 组件的生命周期
   */
  lifetimes: {
    attached() {
      // 如果有项目ID，加载分支数据
      if (this.properties.projectId) {
        this.loadBranches();
      }
    }
  },

  /**
   * 组件的方法列表
   */
  methods: {
    /**
     * 当项目ID变更时触发
     */
    onProjectIdChanged(newVal, oldVal) {
      if (newVal && newVal !== oldVal) {
        this.loadBranches();
      }
    },

    /**
     * 加载分支数据
     */
    async loadBranches() {
      const projectId = this.properties.projectId;
      if (!projectId) return;

      this.setData({
        loading: true,
        error: ''
      });

      try {
        // 获取分支列表
        const branches = await branchService.getBranchList(projectId);
        
        // 更新组件数据
        this.setData({
          branches,
          loading: false
        });

        // 设置当前分支
        this.updateCurrentBranch();

      } catch (error) {
        console.error('[分支选择器] 加载分支列表出错:', error);
        this.setData({
          loading: false,
          error: '加载分支列表失败: ' + error.message
        });
      }
    },

    /**
     * 更新当前选中的分支
     */
    updateCurrentBranch() {
      const { value, branches } = this.data;
      
      // 如果没有指定值，默认选择第一个分支
      if (!value && branches.length > 0) {
        const firstBranch = branches[0];
        this.setData({
          currentBranch: firstBranch,
          selectedIndex: 0  // 默认选择第一个
        });
        this.triggerEvent('change', { value: firstBranch._id, branch: firstBranch });
        return;
      }

      // 查找当前选中的分支
      if (value && branches.length > 0) {
        const branch = branches.find(b => b._id === value);
        if (branch) {
          // 找到选中分支的索引
          const index = branches.findIndex(b => b._id === value);
          this.setData({
            currentBranch: branch,
            selectedIndex: index >= 0 ? index : 0
          });
        }
      }
    },

    /**
     * 分支选择变更事件
     */
    onBranchChange(e) {
      const index = e.detail.value;
      const branch = this.data.branches[index];
      
      if (!branch) return;

      this.setData({
        currentBranch: branch,
        selectedIndex: index
      });

      this.triggerEvent('change', { value: branch._id, branch });
    },

    /**
     * 标签模式下的分支选择
     */
    onTabSelect(e) {
      const index = e.currentTarget.dataset.index;
      const branch = this.data.branches[index];
      
      if (!branch) return;

      this.setData({
        currentBranch: branch
      });

      this.triggerEvent('change', { value: branch._id, branch });
    },

    /**
     * 新分支字段变更处理
     */
    onNewBranchFieldChange(e) {
      const { field } = e.currentTarget.dataset;
      const { value } = e.detail;

      if (field === 'type') {
        // 处理分支类型选择
        const typeIndex = parseInt(value);
        const selectedType = this.data.branchTypes[typeIndex].value;
        this.setData({
          'newBranchData.type': selectedType,
          newBranchTypeIndex: typeIndex
        });
      } else {
        // 其他字段直接更新
        this.setData({
          [`newBranchData.${field}`]: value
        });
      }
    },

    /**
     * 显示创建分支对话框
     */
    showCreateBranchDialog() {
      // 重置新分支数据
      const defaultTypeIndex = 0; // 默认选择第一个类型
      this.setData({
        showCreateDialog: true,
        newBranchData: {
          name: '',
          description: '',
          type: this.data.branchTypes[defaultTypeIndex].value
        },
        newBranchTypeIndex: defaultTypeIndex
      });
    },

    /**
     * 关闭创建分支对话框
     */
    closeCreateBranchDialog() {
      this.setData({
        showCreateDialog: false
      });
    },

    /**
     * 创建新分支
     */
    async createNewBranch() {
      const { projectId } = this.properties;
      const { newBranchData } = this.data;

      // 验证分支名称
      if (!newBranchData.name) {
        wx.showToast({
          title: '请输入分支名称',
          icon: 'none'
        });
        return;
      }

      this.setData({
        loading: true
      });

      try {
        // 创建新分支
        const result = await branchService.createBranch(projectId, {
          name: newBranchData.name,
          description: newBranchData.description,
          type: newBranchData.type,
          // 从当前分支创建（如果有当前分支）
          fromBranchId: this.data.currentBranch ? this.data.currentBranch._id : ''
        });

        // 关闭对话框
        this.setData({
          showCreateDialog: false,
          loading: false
        });

        // 重新加载分支列表
        await this.loadBranches();

        // 选中新创建的分支
        if (result && result.data && result.data._id) {
          const newBranch = this.data.branches.find(b => b._id === result.data._id);
          if (newBranch) {
            this.setData({
              currentBranch: newBranch
            });
            this.triggerEvent('change', { value: newBranch._id, branch: newBranch });
          }
        }

        // 提示创建成功
        wx.showToast({
          title: '创建分支成功',
          icon: 'success'
        });

      } catch (error) {
        console.error('[分支选择器] 创建分支出错:', error);
        this.setData({
          loading: false
        });
        
        wx.showModal({
          title: '创建分支失败',
          content: error.message || '未知错误',
          showCancel: false
        });
      }
    }
  }
}); 